{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.357862\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 2.721847 analytic: 2.721847, relative error: 1.853576e-08\n",
      "numerical: 1.532857 analytic: 1.532856, relative error: 6.346561e-08\n",
      "numerical: -0.842269 analytic: -0.842269, relative error: 8.304003e-09\n",
      "numerical: -2.133761 analytic: -2.133761, relative error: 7.222291e-09\n",
      "numerical: -2.834365 analytic: -2.834365, relative error: 2.233357e-09\n",
      "numerical: 0.329528 analytic: 0.329528, relative error: 1.253682e-07\n",
      "numerical: 0.208577 analytic: 0.208577, relative error: 2.694352e-07\n",
      "numerical: -1.047707 analytic: -1.047707, relative error: 2.556216e-08\n",
      "numerical: -0.696289 analytic: -0.696289, relative error: 4.621149e-08\n",
      "numerical: -2.851442 analytic: -2.851442, relative error: 6.027063e-09\n",
      "numerical: 2.431695 analytic: 2.431695, relative error: 8.498316e-09\n",
      "numerical: -4.271284 analytic: -4.271285, relative error: 1.909620e-08\n",
      "numerical: 0.433176 analytic: 0.433176, relative error: 5.001406e-08\n",
      "numerical: 0.427816 analytic: 0.427816, relative error: 4.575724e-08\n",
      "numerical: 3.336449 analytic: 3.336449, relative error: 3.205860e-08\n",
      "numerical: 1.670408 analytic: 1.670408, relative error: 1.337797e-08\n",
      "numerical: -0.668865 analytic: -0.668865, relative error: 7.445913e-08\n",
      "numerical: 1.248163 analytic: 1.248163, relative error: 5.157722e-08\n",
      "numerical: 0.088800 analytic: 0.088800, relative error: 5.900562e-07\n",
      "numerical: 0.840546 analytic: 0.840546, relative error: 8.533816e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.357862e+00 computed in 0.310317s\n",
      "vectorized loss: 2.357862e+00 computed in 0.066602s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "tuning",
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.352490 val accuracy: 0.367000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.331980 val accuracy: 0.344000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.342306 val accuracy: 0.352000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.309429 val accuracy: 0.339000\n",
      "best validation accuracy achieved during cross-validation: 0.367000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "#pass\n",
    "iters = 4000\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax=Softmax()\n",
    "        softmax.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=iters)\n",
    "        y_train_pred=softmax.predict(X_train)\n",
    "        acc_train =np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        acc_val=np.mean(y_val == y_val_pred)\n",
    "        results[(lr, reg)] = (acc_train, acc_val)\n",
    "        if best_val<acc_val:\n",
    "            best_val = acc_val  \n",
    "            best_softmax = softmax\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.361000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAFrCAYAAADVbFNIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9edRk21ne975nqvp6uPciYQISEo4hZjSDCWAcbMZALCxQRIyjMBgzrHgZzFJYNjJEcRRbWJgF2CHYJMbYJgIZbFnBYFiJFhFOwGCwwRgHEsUQNCDEqOHe7v6qzrTzR9X99u8tnfN139tV3bdPP7+17rqn6zt16gx779r1Pvt5X08pmRBCCCHEkinu9wkIIYQQQpwaTXiEEEIIsXg04RFCCCHE4tGERwghhBCLRxMeIYQQQiweTXiEEEIIsXge2AmPu3+Ku//a/T4PIUTG3d/k7p8x8fofcfc3HuNYQoinj7v/fXd/5f0+j/vBAzvhEUI8OKSUfjyl9MH3+zzEvUMTVvFMQxMesRjcvbrf5yCeOnpuQjzYPCh9+Bk/4dn/Svg6d/8ld3+nu/89d19P7PcX3f1X3P2J/b7/Kf72Je7+E+7+zftj/Kq7/zH8/VF3/y53f7u7v83dX+nu5b26RrHD3Z/n7q9z9992999192939w909zfs//077v697v4Y3vMmd3+Zu/+Cmd18UDrewvm4w/56KEFPPTd3/yJ3f/P+Wf/X9/H8xQFPtW+6+6vN7Plm9kPufsPdv/b+XsHDi7t/jLv/3P678fvNbI2//XF3/3l3f5e7/6S7fyT+9hx3/8f7Z/6r7v7V+Nsr3P217v497v64mX3JPb2op8kzfsKz5wvM7LPM7APN7Peb2csn9vkVM/sjZvaomf13ZvY97v5++PsnmNkbzey9zeybzOy73N33f/tuM+vN7IPM7GPM7DPN7MuPfxlijv0E85+a2ZvN7Pea2XPN7PvMzM3sVWb2HDP7UDN7npm94uDtLzGzzzazx1JK/b05Y3EJd9JfzfDc9vt9h5l9ke2e9bPN7P1PfqbitjydvplS+iIze4uZvTCldC2l9E33/MSFuXtjZj9gZq82s2eZ2T8ys8/b/+0PmtnfNbP/0nb97X8ysx9095W7F2b2Q2b2b2z3vD/dzF7q7p+Fw3+umb3Wdv33e+/JBd0tKaVn9H9m9iYz+zP49wtsN7n5FDP7tUve9/Nm9rn77S8xs1/G366YWTKz9zWzf8/MtmZ2hr+/xMx+7H5f+8P0n5l9opn9tplVt9nvRWb2rw/ax5fe7/PXf+F53La/Hj43M/tLZvZ9+PdVM2vN7DPu9zU97P/dZd/U87u/z+6Pmtmvm5njtZ80s1fa7gfGXznY/41m9sm2CxC85eBvX2dmf2+//Qoz+z/v9/U91f8elPD/W7H9Ztv9ogi4+xeb2dfY7heImdk120VznuQ3ntxIKd3aB3eu2W7WW5vZ23PAx4qDzxSn53lm9uZ0EKFx9/cxs2+zXfTuuu2ezTsP3qtn9czitv11Yr/n8N8ppZvu/rsnODfx1LmbvinuL88xs7el/Sxlz5v3//8AM/tT7v7n8Ldm/57BzJ7j7u/C30oz+3H8+4Ebdx8USet52H6+7WasF7j7B5jZd5rZV5nZs1NKj5nZ/2W7kOvteKvtIjzvnVJ6bP/fIymlDz/OqYs75K1m9vyJNTivsl007iNTSo+Y2Rfaez7XZOKZxKX9FfC5vZ3vc/crtguzi/vP0+2b6pf3n7eb2XOxfMNs1yfNds/1G/C991hK6UpK6R/s//arB3+7nlJ6AY7zwD3fB2XC85Xu/v7u/iwz+3oz+/6Dv1+13c3/bTMzd//TZvYRd3LglNLbzez1ZvYt7v6Iuxf7xXiffLzTF3fAz9iuc36ju1/dL3T9j2z3y/GGmb3L3Z9rZn/hfp6kuCNu11+neK2Z/XF3/6T9uoO/bA/O+LR0nm7f/E0z+3339lTFAT9lu/WpX703BrzYzD5+/7fvNLM/4+6f4Duuuvtnu/t12z3zx/fGgjN3L939I9z94+7TdRyFB2VAeY3tJiX/3/6/kDQppfRLZvYttnu4v2lmf8DM/vlTOP4X2y6U90u2C8m+1sze79J3iKOSUhrM7IW2Wzj+FjP7NTP7k7ZbgP4HzezdZvbDZva6+3WO4o65tL9OkVL6RTP7yv173267fqjEos8A7qJvvsrMXr53AP35e3fG4klSSq2Zvdh261jfabvn9rr93/6VmX2FmX37/m+/vN+Pz/yjzexXzex3zOzv2M4U9MDiUdp75uHubzKzL08p/ej9PhchhBBCPJg8KBEeIYQQQoinjSY8QgghhFg8z3hJSwghhBDiblGERwghhBCL59LEg1/4sh+5CP8Mfc45NYzjxXZZ5jlTUeXyUwVs/wwiDeOQX8dxxhBpytshfUDYJf9jTPk4wzBi9xi9KgqUxwppCRz7YA6IzygKn9g7nhJfL2z6euYoi/woCtzT737VZ99JLqE74m98zUsvTqTE9Rdl/uxhyM+nrPLriWeB5+bhHuXzrmbaBe97VTcX232XP7cf0tTuNo6xasTI88DcvfC8XfK53ckzxz5skym0sXyuHc57HLE/nnnX5fP+8//9tx7leX7Vy//wxQfUTX3xuuPaO/bZYbriRuI5p+ltxz3k/Ul4TvnumFV1Ph/e/6rKrx8GljmmtF3HE8wfzfOOF5GPk/Lz4EkNM9dZo21WGB8Km2uD+fXv+MafOVrf/Msv+LSLA1fojxaeQ4GXp8cjPiq264Rx15y/c/PxS9yLEPnHdo82xftbeLwV/Ff4jihmPsOn+2mJI3noy/gAXGfPvtnnbT7/Fvts0dZe+fofO8rz/I8//6MuPmx1lss+Nk0e73gfSvYLHIePidfOcTkMy8P0dw7HTbbfqsZ3Tjh+LCMZxohx+rs2fH9zk+Mp7vvQ5/uO7hvHUPyB7XfAc+3b9mLb0SD/t+//t5PPUhEeIYQQQiweTXiEEEIIsXgulbQSAmZRHhrfc2czK2xaDmKYnaHPAWG08F4EoxgSn9OPGE4rGGYb43mGkGgIrfK0cSycd11Nh5n52VEwmQ7NhbD8OH2PyiKGFI8Hw9eU0BDKR3iYIfQB7y1mngnvEZ9zUc9IiQx38ix9ens4kAYpJ/EeF7jLK3w2Q8pszwx380x4/UXJ0Cz2pizLtmeUAXLY9VgUuNdVla/LKYc4ZSyEkIMEhOulHBKkRw4T7ON4mTJEkGS4z/Q4sPsT7yOlGz4PyuTsX3ggjI/zVHtKOjxXyLBB3qJklI9JmeSYrJqzi+26ohQ1LRmPlGQp++CGV9h/u91cbPcDexvvF8eg/DJlDErhyTGeFPG3c+j/QTKeHuf5bAu0GR63xDjlsbFikydOCQzX6TzO8ctJNitIuiXvKcdWjLlcUkDJiOM1vxOwHe5bwT6BbTZ9frXg3FK4n/FZOh/IyIeWNwfI9nw2lNvZr0u0cUpxlCTZ7vqO3108BciBM7I9UYRHCCGEEItHEx4hhBBCLJ5L43k9w/XjtHzgYYU1VlUzlB2i4Ai1BXmjmNzHZmW1GecIwnReRgkkRtFxUkFampHiSsYCcQ0IcfP4DEH6jMshONYQdyzL00ha57fO8zmt6f5AOBIh0pHy40xonc4bypJ8b5EYOoWLCGHQ802WXLj6nyFOT1FOCJJgCPEz9J9h9NrL6fYWXCg9jw8JjC6BYUZOAXQkHIu6ye4Pylsj3WqQ80rL23Q1FlSfcD/ZBptmlffB8dk/PMgqGbouojsoEs7JIT3OuMWGMd/Tttvm87aZNlEyJI77QncKTrzGvavYltvjy5O7c8rXTAkxjLWUvROvB/ImZT+E+LsO7YKSPCSKspyWhlr0U47rlGKCjGnRkRPaAKRLjs61YxzB2MnnwDGY50F5pKAkwrYanEb8Dprus3cDx8QqLBfA/Q1tcFryC+bIsMyB34mZopr+3hg5pvM7mm2f42ERvijjty5XJxSUgPF9F/pdNbk/pVG6Xr3N/Tq6cKfbNa956G8vTyrCI4QQQojFowmPEEIIIRbPHS9RD+FrJokKUybIHlxRz5D7TCkLSh08ZHA7McTF8Cb3YWj9IIQeI3UIkY0MpzPEzaRpkElmEiZ6CL/joxA1je4SnE05HdY8JtvzLGnRwcF7aZD0Bqc0xORhhtexHYwTeC9Uog4h+vM2hzLPz5kci9IoXXMx1BpcdCWlNZwTpTi4NmrKXjindmB7g8wYFNTpZGh0G4xBTsiSy7FYrbKkFdxuIXEXTrqa6V9B3pjWoXs82JDgsUDCw5nkjZT5UuI+FghOq2JacmJCztTne+pMuOYz/SvoA/yoYnobYxbHgTqdpm/yXlaQEGOyxenEcik40yjt5vu4PssusB6SLN1bc8sEQgJSvJeuxN6i3DxSGub5hTEFu+DtzYp9c/KUQnsLifhKyrt4nfJ34rUdX9IqkXgzmI/5nUg5CAlYG47LlKiK6T7Osw/uWZv5jsIzLutp16Qf9s2QUBb3FFIUnYIVdXImQOT+bAcDv3/R1nCdXQGXYYtrCC41ubSEEEIIITThEUIIIcTyuVTSYuiewdRyxrFkM+HnUCelmA6jpZmEVHFGRqfQtKQ1xjh2eHeQRIJUMp0wr6LrCtfDumLh7EaG+Hhfpt1eVZAH5up8HY8OK+CHFVa6h3yRuE4mqAvXk8+1ZyiTbhZcW4d7vYX80KYc+t2y9tQ4fX/9QAepEV7tcE6riqHj/J4W934IbRuuK7g26Exj7sQi1HiBwwt1ebouu3m2J5C0bCZxWY17xARzdKMEM1kIj087a2hkia4TDB/FdLLB6O6cTii4+/d0fwm18WbcReasUYSDzshbc5nYfMZRwkGoTPmzjsnq7PrFdlXzPlGun67vxethksQCjqiwxACh/xbtdLOFTBikep5p/mDWarM2LlUIjqQgM2XYPnm7OYYPHKcTj8l2CAmJMrfzvfjgjm3+9jLIU6VaZUkyqlKQamvsA0mrxvY4424u5pZIhPY+Lds5+g3ryDGx6iFcJhIcdOH7a1r2Yk3Fnm4/NoRy+ru4x7KAkW2c3zNMQFzcPn6jCI8QQgghFo8mPEIIIYRYPJdKWjB2WB9MDtNJr5iUaC7J0kD3R5Coojfr4vgIjzGcxuOnudD1Yb0em5a0aCOaSxSVBiSPC9FurKofQiw/vxf71EhKNTjDdKwZcxpJK14zwrpwXjDplMP5NPaUnKbPj1LPABmnD/IWJJcih2/Pe7SLASv1GU4NhWDMKvy7wDmdISzaUE7rKLmFjJl5m04rXDPD7xWkn2HbYv85p9nxf1cMoU4QE8AhwSDD9ZSWQvJPHJRJO4Pjgw0e7XeYljBjkjDIZGh+VRmloaJiu8uv95BcWkiGdI4lm24v/DnHy+G41jA5YzV9PcHgdYLaS2ZmzSq7qIILcua5BbU+MaHbtFNwaHN/7FivCcdngkxnX+65v2F7vm4h65JBpbFESX8FKbbB9gquJbrlqmnJcQxJ+TCOsgYcGnoHh98dqCBPGSaRDFoapZiZvka3LpNIjjM14kIdKi6poNsLbTbIQVyzEWTRg4S9uL9sC06JLtRRnE5M6xgHxyG2l4vTSPwe4DUzseFMEtHy9n1TER4hhBBCLB5NeIQQQgixeC53aWG7jHFd/GW63kUoW89w9VzWuuA6QRKuiqfIhFTT9a9CAqVLalIx1J5Qtj4kN0MYkbWhxnCdOLsQi2cCu/zywCjijANjJjfjXUO5ju6XOiTKYsGp/Dplw47X09HZY9gHTgs6O3D8Fvd0M2bXQk/ZKyQCjDdmbfk9Bc7vBq6tRM2lFR7PukJYFMesGM7lMwzNFnVgeu4/U0vO59vh08UhLRWQh7xmaBl9CjKcoz+ynhki4iF5Gp0dvBFBCsW5sfYWP4vPcgUJxyzKx2PK59QnyoS0rVDemE54ygfLlym3lDUTplE+RR/nODATir9bSibODO4cQLsUz4l1pYJ7NT8f9sce8sXIQTgsDZgem1rIXqGO3AEDjstko3wQV+tr+TMo42N7LKdloBT0SshYaPPBFUh1hH3Hjt83g+WM9d9Y/8xDg8y7z0hD7L+svcX26EzwOlBuxEfVlLroPOazjG28KaclN45rZUgWyu9pXD+b2kFKzSlCEmFKWkEO5PXc/otTER4hhBBCLB5NeIQQQgixeC6VtOaklTLUD8ohToYZ6faBWcCqhgmKEFLjB4RV61xhzoRkKCMfcpbNOLHsILkZqCAD0LUydCxVP0xuh5pUIQHizCp0ulZYwwvnzSSHx6QsmBAKrggkwUoIU/bYHlljC8fcQKPbQB7ZUt5Cu9gy1I1r7pA8DiqZbeCCKg4SD54hHF3jnpVwJ5V4DlcSZTkkFcS1NQyDo9bXgGxfZwyzhxpzdBLY5PaxoPOCtZfogvEZSYtaT2IWM/bTUJsMLrst3Irh2vP5UOYrGZYP9bziXem7aYlmGHlPIVWy7hUcPkXNcDr6F6Q1yliUw8oG94uJKYN7yU6Ch+R5dK/ShUN5j/IWxh2uPKAUMeOypTuK9cyYOHPgcARXG987HMjNlBo4pnL7HONFb+fYzqw914xrCjq2mKiVMt50GxtnXLOH530MGrjMwvcgEy3W7L95fzrLyiCr0j2Me1uiT8ARVbOWHx3GaFvB4RQKEEapMnw3VdNJHufqsAXZM+zCOQTlN3y3on2FtSAzCTjTTEJgogiPEEIIIRaPJjxCCCGEWDx3nEUrhARZ6yhB0kK8kuHkEo4KZv0Kq+5nQrqckoWkeEwARkcQnQYHybBC/Z6Zujx06TC85iFJIk6PtTzo0hlYN2Q6IWEZElHlXU4laTEEyfotlC8GhIcpTYTV9pB9brX5Os8pYznrZOXtm2N+bhtKJQwzQ3LZQFYqDubnrJ9VIeRZoW2sKL9CK+tQv2XFGlII6xc9k1rlz+3Rdq4wjAy5NqFfUH49FgyD09nBxJ4xoRnlGkoDuG8jw++UpSh7UA7ICdzoXGMYu0A/oMTQtjFsft4xsSeTmc7U+0H3r9eUEHDexbR01SLx3Ip1uygBBpcpxpcTubQcSThTmpYBQv1A5rPDPWrWGEcHtkfUi0PbpHpBOXREP00FHX68R9MSrtl8bSbevlBXCxd0jqSlBepS8TuoxvU3IRMf2j/dnkxox8SYJ6hbWLE9ssnSpYUxt6xn2ji+N+hWrpkIEN9pFb9zQ7uZSboYHHpM5BnvCXMnBpMWjtv3lKUot84kW6QsxUTDzYykN/D8Zr7H7yB+owiPEEIIIRaPJjxCCCGEWDy3kbQYdsJ2olwz7RzwEL5jfSK6KBDiaihXoYZTonyGTYb1ZurNHFoqGIIb6BAItaTy/kxmR8cDlTGGWcsgkyHExxpL2KY8wGRK6ZKEXncDV/fTsVXX2QmRRj4HPkO8jn1Yy4WJCocE15UhxFsyRJ2fIcxY1g4MleYEdYdS33kHdw6eewPnERPRjQMkGLob4Ixo+3wiZ5BZGyT34/EbSiiUsegQOoFPi2Fn1jRKvEdM5sm6OXRpIeRMF+PA2jp0DUHCaxMcdOj7vN6hQy2zNjtxDuuLsd6a1WynlL2nXZ10HIY+D6mAed4oWw44JqVQOqKqINXbSaBEH5Of0nXEZIDMpMfaaLiPTDTKxKFom+doOx3kR7oyx5DMNZ/nGByqkRRqsYUsnHg5FF/Ee3kNlNby/kysVwbXJPo73X4h+SHGvhPULQzuIsqq6F/R3cnElrltNkzAG+4nM7/i+4TfG0FWgmQ/4zgMbW6MbicmaqTMNAQ3FxMQ0zWHU8Vxw9Xg2fRh3MFOdFniuytc8x0keFWERwghhBCLRxMeIYQQQiyeSyWtMjgepuUthgrpYCgRiq1Yu4R1b2q6t5Dwbsyh8nImhEzJiEvSg4PqcLU5XVFMkuiQtFB7iQkJGV5kuDcxMR7lNxzHRspY+bPajtILQp+sbXVUmFURmzQRIdTKAGGCY2vYQj7yKxfbo2e5aoNbUTe5Zs6ABIM1Qtow7wXXXN3wLOLzdCZunDbwmPN5hlpnWd6q8OFrPIcrkK7W3K54/byRTLaJNnyC3xUMA4eSdOgAobYb69DBycKEfy3dVaxhF1xa0869LRISMpmbI4Fdt8nblNLMzByuQUooLcLmBRxIHpKWsr1grEE/ogQEVdUKDDApjHG4d0G2PUUaySgVUWvwkCQPkhPD+kjVt+2nlxswyV+L8btHe+lwT0OtQspKHB+Y5PIgqSvlDt6yIDGzLhvaQ0VnFtszt5kAD+fNem3h3gUpDedTHP95NmjLlBvZZ9PA70265uBEC4Uaed8oH0/TYfyhpLXyaYktymEH7mbWT2O/pZORciuTCrKG20zS3TB4h2437Wrj97JhWUTf3d4NqwiPEEIIIRaPJjxCCCGEWDyXSloNXA5MLMYV4EzItsGK8QFJ3oYeK6zXqMXCyBQkA7ooPKy0Z9gMK8cZWqVj4aAmCIOuZcnV3XRUIaQI6WLFO4UDMeFSv9nkQ/bYZiiPjjBG9Sw7pfxEYXOubmdSrgRZgyHrCs3jjPIIkt6tV9lFtYWkVbYIZULS2sKxtUFys2tn+fjtyFAu3CtFXIXPkOzYQqJC+zmDG+s6c1v2ty62rxa53V6xHAp+FNLHCtJViX3KITuPDJJmRRdhdRsz5NPAcfwyOFkojXAfyEGQEtshXwudSXRH8bNGaKFUerpNvv/9zXxvU5v7AZNxRsHUzCqE4FEbbKgosbKGXd4nJEZjDTDIHkFWCbWBcAqQtwrIDBxfyiFKN8ciqGbU5el4Q/saMQhtIBv2eA7UrVmfrsW97/lsa0qGuL9huQH6HB2BB7UD0zj9W5rJHYNDkK4inEfPhHgzt76zaQmFjiI6vMaBss7xf/MzSSCbed+zptVMzUfKO6GOGtxVeJYFpSFsD9vcDjomcqQxjo6rYdoNbXZQX7LIba2eqQEWlqrQIUapG0sHhplEw6zDF6YfrAVXP7WxVREeIYQQQiweTXiEEEIIsXgud2mx9gWT5CEkyJXzDIWdQ2LoIW8gIkbzh6WRoXg6qPLLXOXdJTq5uIIdCZAOVuA7wmtMEugI5dcM06JWUL/J0kUBGYvOrITEdu6QNyCZ9UzQhHDcCppZdaJaWjVCxQVirc7wM2uf4AFdKa9ebK/qvJ0qyFWQGa7hmVDqauHS6rBtVd6nNzpQmKArPk86CwaGbfE8mRjw6kz9rCbl965TlmAeaejGggupu5m3WziVOshbCDuH0OyRcMqTxfT9shl3DWvOlDVkSFwvJRbKDS2cEC2dPwih33jixsV2dzNve5CYD2RbPP9inZ1/1dUs9dZI6BZqWkGvYd0vuouYPHFE22fTd8pnlAxZo6g/jaR1DpdbBQkpYexoezrh4MxCP9jimRS4ng79GrkgraUcxIR8KzjcINGw7hGlLj+QtMZQpCtvhiSZuJeOxHJ9Mf39EpLYoR12PTWXaecQJVCeaXcKiRLnz+8vupfcp8+TiXMpM/V4rixIxqSYQ5u/E7c3cr/r4dhir/PQx9HGDyT4igk8KYPREQhnWp1XORzU3aQjcrrmHxVGyl6UAD3UueN3lxIPCiGEEEJowiOEEEKI5XOppEUFgWFWJlZi8reKDgm4YzZwPAyopzOEZGCQNBjuQkjXeHycXNfBEYUp3PoggR9Dh0VItEQXFWr/MCEUwn+htg4SD46UUnDeTG5WM4KKc63gUrN0+wRKT4cKrpUeyQOdtb6Q9K9BEremynFKh7xVrq5fbG/hnFsb6mqV+b1d0eD1/My9YQJDSjG4132s8RLru8HZB0fDGcKiKzyTEu6kClJk4/n1q3DylWNutxskemuRJLOHLGP9tNPmaNDZQXmWiixeZ50kuq6cDkeEsulW7CAZbZE88PxWdmO1t7LMt0Gf2GwZiocchvD77jzwPDr2l7x9/Uq+vyER5gYOlvN8nDUHMOc4lV8u8Wz6qD9Mbqc7qNfzdKDZZot7NmBcGKjcBIkKEh3aIOWBvhiwzRpbeOYzNbPoGmN7Yb2ssjgYa+eaPF1eLZMkwl21Rm0/OsoogTHfJxNmQqMsuLwB3zUc407hhx0w/hS4jyVqxFFC4rUPYYkExzRKgfi+Yk1I9LsBzr0By0tCslaqTTx+EeMgCeddMZkn20UTDpbPj4dCo6irZnKfYe6B0LxWsT3yzbeXJxXhEUIIIcTi0YRHCCGEEIvncpcWlnGXCEetEPouBjgnCjqkEBJlVHsmmdIQMm/lcNd2g0R9kLQahD0LSkAMjR5kqmqC+4k1PniCcDmEWh6QWTqGR5lsjhIL9kFokvfRIXX1LZK1DdHxcCxCiJu1bvB5DimmRDh5hZX6qyrf+6rOUtQWzYmSVrHKTq4Nap+MTZa6ynWWyQpIpgWeebuFC8osJPor6MKBXFIzYSDcCsVIyYK2FbRJNlwm/sLLxQBJCNdskO7quYJwdwGTeAUHg02H60PyMLZNHGaMWcnyeyEHUK66eQsyHxLetZDAWpp1mPyuj22cLjvWraN7scRnr9dwdWHsGHEeI1yQ6/V0MrgBdrqQVG+u1lEXZdVj0QcTDiQLtJ0O42sHCYLGMW4HpxS1zgZJTsNXAI45nWfWnONrkEbhuDSzhP5ItxElnoE1ELGdKHeEQnGQHzvKWEwQywSbkNUpdTE553j8vhlMmayLFpIKwkG37Sb35z3ks+ng1uvOkdgTjYjJbhPbLBPfog8OeL08cAmnDlJcjfu+wtIWDqf5lIJ+TJclP2GkNBpqSjKhKmQ1usdnnG9zKMIjhBBCiMWjCY8QQgghFs+lktYWyfYqrPKnSyn1CCHD7cL4NXMDhVpXCNltUXNnQMiOIfGOrpMt6u3gs3qsTr9ZRkdFg7DY1TPIMkxkFKKIcELgOgeGICGBhFAm5S1KfdipafI2Q/zDQQ2wY+GQCkbIQSVCv1WR74tBrkEORisaOLmgDzDp2ypklUQCP95rusDOcA6rfA5MjNefRScIE/3RsdUjidmwQeI77D9uICFu8z6GfVpIGQWkjxEOL9Yx6lgrxim/Ht/Zw0h8NGxN16VhGJ9qEhMSJoST2QRHaKGUfVr2j4Qaaayp55Q9cAFRAQn9gjWaKL9t0OnS3AgAACAASURBVO+G89wgV5BAS1z0iP5eoq0xr1oR3FhMvoaThWw9plP4esy2GEco3VB5pZjGhHkd5LeW9x5ttgxqK6QFjglwslHGpIQQhEhIWgXqn5kdSBwd65JBcgrOVEhgPp/Q8ElaXHNT0DmEdk6zK+4X+7L1x18+wISMzIVH2c6D4IxxFg7FHtI8a2Mx6SLbbEgkiPtDV5fhvXRi0q1YH8h8NeVGSl+wHFf88guSOa95eslHkOHR9qsG7QtSZWLyS/b39vZysyI8QgghhFg8mvAIIYQQYvHcRtLKYf++YPgLoaYQ6scKcCZQ4gpzlsCZSYDGJEh0SiXIB+eQIVg/pg8J1uJ8jkmXbsHldbbKbqEG58HweApFvXJYsEZ4beD++NyCx2TdI4bxcZ39iSSts7PslmqfyM+220CyYH0kLLcfB6zIL+AMSPk5rM6y08rhjhrgqAjJI5n0Do+qQ6Ksocmfe3hfui0STtJVgkSUwzYnxLNz1MC6+cTF9vbmu/M5wY2V0JboxmuRPPO8Rd2oIr+3ucZ6L5AJjwVvWEEnBOQdOGJYuC5BoqJ7hdJwcMTgnoT6XHiWPa7dkUQ01ONj3zxwglRwXRklLSYYZSI2hNav4PpX+OyGteNYGwsae01Zhm4ijmUFHSyncVAODOvj2VJWHY33Ir+XdbJGJiFk4lgmEuRYC/mXKwCY3I21lGpIC3QK1nWUbUscbOiYYDDvM5SQ33BBVFTK8L0ACaXG/Uocp/N7g2ON7iQmnT2BI7YIskzQT/N2UJ7Rj/AdRWk3sR8FJxOlJMqCOD6fBWThAp9VY5/qIGsk5So6fUOtMr6FDk+uZ5lpUwluLEMNtyK4tOgaxfdmcJrdPmGvIjxCCCGEWDya8AghhBBi8WjCI4QQQojFc+kaHq5h4CIJ2sIqrH/pIeN2tNdBZ+uxFoJrMgZYoHtogy301hbZWPk6tX3qyv0wvxamhZbZnuX9uIbnDPboBto1HYVb3iOsz1mxaBzXKuHNmzbfly0sdd0daJFPhzJ4U2HfhGUzwf7YIWvtrVv5/G6d5+1r1/K5XrmKQqrQfTs0M1/nzMyOz7J3Yd0C123R4nnwPFkgj0XtqOWOWG9jWJM2bvP25sbj2D+v/2mZKoFtDykKWmZgbvJ5P1LmtnPF89qmY8F2HiyuuO+0orNYH9fwjFhUF52l6F9Yg8ElDymswcPncj0HNuuENtcfrPnAe7ieh2t4ErPoOtcRck1O3l4z03LDtWP5cwumieCaMrQtrv8Y7TSZlmkz51qMlhmV8RwwvIZ7xLVaXP/CNUxrjGsj04Tg26BGFt2G27iPXLZxaNZngdq+wvq3LdOYMJM91qWwbWONGdtnyVQPtOhvue4u78LvrJHrZO6g4ORThmtQ8WyY6mAMdnLcPa5twb22YEXPD6riGidmDceaKBZa3ZZM6Y3M4mHhVIyDDPgb016ELBM41xLpQ0ZcT4F+XZ2hj7MY6Bmy7GNMZz/gOq3OeK9VPFQIIYQQQhMeIYQQQiyfyyUthLXLgnZXxoRhIUWQa0A4fYRnbcQcq0d8nCFdSl23kG2Sr1NuoKx0WYiSoUMWMWVInJbaCuE/Z0ZhhPwqWu0gG9RI50rLX8L5DQWyHbOoqp1G0kr0qRolLdxvFoS8hUJxlkPR5+fIAIpneI730mY7orDg6pFHLrZ5rzvInufMDIopeX0QamXomFfGTMgF5Kf+FmzpkCx6FCXdnOftd77zHRfbtMT2Rut+flbrq/meNo9AxitiFtpjwDQGDEczY2oZUgpDcmIhxZD9NO/OrKgJ4fchWIPRxhl+R3sK9RJxnObgntA6a8hSzYKDJUPilJtxHhUt+thuSmYXNuyPc+INGNE/UC22TyeQQMyshbydoEGMTO+A8yuYRRrPmdmSmdl6hXu0qvO9G5hdGd1rjQKjV87ysoW6okzGzNzxvnBcCDZ46iA1JdHpzMBF4ntZ2Hg6w+6GxaYpFUFaYhs+RebsYub7gekQemiSQQ7m9dJyjmc8oEgo23vIKhEyX8NW3nMpCPo4C9Z6HGc51gTLPSQntsEKqTG8CZ0N7y0nt/mMOXgUzBxNCRtzi/YOEtorwiOEEEKIxaMJjxBCCCEWz6WSlrMAKCPODFNju0TYlAXqGOxMyI5780aWGLbMoopwrTNDKD6LWY37nuH96YJ0ZtGp4DhYMDmE16eLmq1Q0HKNsB4dIg1DfIgt9ygSWNYM2dEpleWWowJpKUFOaxHOfHyTXz+Hk80p4+AWs0BjXeaswwOux1HcsUaG7ODww2neghsF6outDjKA1uGfkHXQbgs4tm4+nrMrb+C6ojR2C7LXO2/k/X1GNqBrZ4X7W59lN9rZ1eO7tOiCiVVrUQSwYt9hBl5IEZB0OhbPxD5ruHSGM8i8IfMxik3ibBKyZvdw/R3+1mIRS/b5GrLn2dV8TxvILCtsrxs606alrgqOoBL9wOkgDTI53aSnyYK+ZZ9nRl5IPZQHKkrmK8gdcK04wv1nV9A2MU6zf1FaqVCQs4Hzi9tsI0F+MbMtMu0XPKeashQr1FJagyyFsT2FdOoYOyl71ywqDSmWz5DyNFP/H4k1rnHF+xKSo3OZB7P1Z+ga5Pdp36Ff4z6U2Idfg7zeAvdnhFQbXGMWocuYsmePHVnYm27aOiwFwZiFz2MBX8rnKYxH+a3MNN2huvhcoVmiCI8QQgghFo8mPEIIIYRYPLdxaUHScDgkEKZjkbkSyQOZvIhyEMPpayRHSkUO6bYIJzd0ZqQclmWywa6dcTUdJCJqIK2sKLNAluI+LLjH4ngrhPjXWA1fsAAgTwMx1wpuFq5+Z9IoS6dJblbBeTFYlhafgOPtBlxNt3hfETrdMElicEqxoF++ttWV/Lne5oR/lDFY6G8zUDJCgUKLz3PFVfl0sDC0CanlCUqocGmxQO0WEsymz/vw+VAqcMgPjrbaXIOkde26HRu6YgY4L8qQoAsyHxrkGYv14Tgt+mnD/nuWnx8UMHO4RWp81gYFL2GyDBJTOnCCMNy9ghx47ZEsB9br3F7WuL/Nmv2aLq1QPRLbCNHPuN0S2iBdMUyiekxayLhFTWmcSUunpUu6TOmWKSGBhXEqyCmQIisWW4UciOKWTZmPw+dJ2cTMbHQ8eIxnLETpJcZ/9O2BbtyEfgp5xINzCO25wnjEBKQcU2ee+bEonf0uZD/M54bXaUwqMbYMcGxVI743+OzRlguO0WEdCZzUqCparDiOswh4bOO8HrodWzo8+X4mi+R3XOJYnqEj1Cl/4vWGTi4W0cUxXYkHhRBCCCE04RFCCCHEQ8BtXFrTifGqmbo59Zp1MBDuhPzUI4S4WudQOUUc1tLiynwmKHoEMsEaiY7aLcKkByEuOht4DWcI97JmVsUkWwzxc7E5ZACG2kqE/pgYjaHyjpIJQu6UEo/J2bVrF9tFlR1IA6a93Ea01FqE9Td03gSnBT4MIc6zAZJIzbB5/oAWmtZ5x1A02ksZM0uF0DG0lgrPZECCr5u3spxGSYvtk8481msbkQyS0iUT49HBwPpDq3V2ER2LrqPrZLrOzAj5pV5Nuw9rSAxnSJxZwOnWlAxFM5yOfk0XFNp4y5sCqTodeEFKJrq7nvv21etXsQ+kG/SpZpXb1ArPY8U+S8mT8iQdLLx5rAWH1/v+NHJzgvuJDrxi9hpwL5zuLbjdmGwS9ZfwOKOMRUcNzqdiIkgkoK3pSjxI+pYgnVAO57hAl1fLrHmhrBOcpRxq0JYosxbOWl+QxukEwr3jGH8sHMlIQyLBIDHTdsTvKbiXKMnCiRfGUDzXkfZZ1mMrMdZhnC3WqEVo+C4eoxOR3wl+BWMZ+p2zxlpNNzCSEWNcYBtkglC2fcpshufHRLkDvyv627ubFeERQgghxOLRhEcIIYQQi+dSSWvosnun73LIK1kOMzd1dkusr+Rtrv5/4maWEhwr6lespcSoHhMdhQI/Oax1BbV06BDY9lwtfpAkbCakGJIEFtOy1AqyWYPzrhG+KxESrpg0igkTh+lV+wnxWm4fk/WVLGmVuAaqDh3CsR0SgHGb9XAG1qqCTOSQWW4O+fmHmiuo6cOQ/jmSsPVwr1xZxfpLlC8KyIAlbuwWyRPfjUSCQdJi24OEELwKCKlWeM5X10y2idoyrCdTXdrNnhZ0UrCZs15cqKvF5GZ0BGH/JrgJ0QdxI7bYrtDfO0hAaySt29YYQ1CzrDtwgtBB+MhVJBJcM5kjnEah/g6Ow0SYrMWDcSTIITYtafEe0QU36wi9S6JZiC5AJm5DG4Q7ls7SuqKbB21kiwSLfC8TPqJdN8W0jBXkLbosuyj1VejPxuR7Yx4vtkj6R4cRE7XyxgzBOTedKK9EO2QtLTqHkrFtH991l+BSdLirgpOU58k2iGdjod7jtFuvxFc4TMyhXlyPa6yuwmFsuf+yPxVDfJZ0pdZw3DZwTTZwcpaQ3OjorpAplnXFWJuSbk0u7RhDP2XdNXzn3IG7WREeIYQQQiweTXiEEEIIsXgujbX3CBdtNlmWuNJlaYS1qxj6jaIMQ1aQNBDGhRoQwrIJYVmuzqZ7i7Vkmpnkf/EsDkKZrP0R6snk8NoV1OthLZqioFsCrghjCJ1JnRB2mwut+/HDrGZmzVl+bjXkiERHHWr39Ej6tRm4Ah7OEehBPfZhgrZiJtJYr3LIkpJW27KGV8ZXcX7O/dJIx1u+3xvIYzc3OfFgj6RkdAxR3mNtGoaOGSI+o5yCEK/D/TGc4HdFB6lupGMLtWVsjQ5GCYxyAEL9JSQdJrwL7hjKRHQ01kguR9mLMhHC5l0bG0WBz4tRfbhDMRbUcJQNlAroHINjk/WzgmRMlyXf29LZQgflafomE+AFiYbut4ryFrYLylIYvzAejXR+sm4fZSUsN6CEQrkpDOyUUsc42lboL0ysV0AqHbbTyw84/HG4dD42dlRKHDgHx/WXuDYmtGv740uUHOM7JHWtmulzCFIX2iMdzSHBKete4Wax3tYKMmSLuoHjwKUWdFXDiTkeTAvQd84gK5/BsVXDlRpqamJ8rFlHjclbWZuT4ylOgbUZWSONYxZrWc6hCI8QQgghFo8mPEIIIYRYPLeRtHIobOhzKItunHabQ3YdJC06U1jmneG4KtTuwYp6hk25mp11mxDSbeDwsIL7H1wQnVAD46OUpQzbdLnglCAPBHfCQWK8vD9q8WxxT+GCS5SMhtMkN2vg0lpdyU471iUqIA8mJhhkQseZuitB0kI4lo+BSf7KgftM1wli6L6DJGVmlig1DJS38utbJKbiZxdR37zYpOuuYmKtmdpwRpkBYd1qTdcC2ueR6CHVBUkLbpyRkh/vL55ZGikNTMsqFiQqbFe8J3mbkh/DzJSCWZPHLIb7S9atYxicCdDwvOtq7tooK/OKsA+lLsrz6Ncj2lAYN44IJZ2hR62gjvUJmYSV949S+vRYNga5CtdMeROHpHsvKOx01yGJHZMfmkWZIoV6SpDckDSvG+iKY1JBLlFgPSXW3rIZmMyREhJr9R0ufLh7EtxCVMwcGRJ5LXQpFfzO4fPAmEMXG9s4P7eCofXqdTrrIOed41nkod66A5mPztrrj+I7hK5ZujQhezk+j4kzuVQlzA+oW1Kq5HcOzw/X7KNcWkIIIYQQmvAIIYQQYvlcKml1HSWtFq+jBgdkDysRihxm3AXOlecMp8NRgFgs6wSVFRP+IUwHKWFgzZSDavEDioL0XOlNtwldKHgvA58hvAY5gaE5K6b3H7hiHtvdJstb2/PsiDsmFe7f6izLWPUaSQgRvuwZlq4YH8dBZ+phdXCF0M3D53OORHRchU+9aQ1pqD0IPyfWUYHE0SM8Thchk0H6zIr+Com1CiYMDE4CnB/cbg3OdX2G5JwnqKUVHJGQXxK2tzdzm7KebZPyQ94eccweoeXC6diBTIRjMrFhA/lkQA0yJh2lRGgW6+TVrI21ZjY1yN547zhMu1mCY4cfxtpYLdsQ7t05pWc6K08jaYUxAh8xDJD6+nyPesqYSArKAZ0J4yiDRBcYkxDmd9fYn8+WrkxKXePhYEsZlMk8Oe46pUsk6sR3AfvyMPPegc+T7RPHoaRLox3b5NFI084vttMRN69hDTuOMzNOJtrjCo5pkJVYR4yJQBu45LZwvZYcKvrYN/kZV65Nu7HYquo1xgIskeCYFWVOfN+z1zL558Dah7HyZj7O7R13ivAIIYQQYvFowiOEEEKIxXNpPK9A6MwTV0mjHsoGEhDrSiE86kxwhPAma92wHg4TwTWo3cJQfDmThItOsT4WqImhXCY35OrumcRiTiMIXAShplGavh6GzTebLONsIF1tN9zO+xwTrrZn0qgrkGVYByUh3O3VdHIzWiQa1EAyJtmiqyDUOoNLDTFb1g9KIQtdlLQog4VnTXmkzG3vCiUnZLoMySNxj2pss/bLCsd51nu/18X2o8/K21cfeeRi+xSSVhr6ye2Bziz0kTHcXyZqY1ZBhJnhjukpT1ICg6wyIpEgnzFrezGZ4eqwvhh/etGlA5cSDWV0tjD52oj3BjcdXFqU6pmQr0OywVs3siOQx+y3p6mlNWcWcjy3IiTPQx/hMBe24fihjEknKt1CoZ/inlINhcwyQsJOUXMJUlEchVlLkDI5lxLw2UKyCckZeW2QPfFpvdGhyedGqej4Lq1o1qUsg3bN55HCN9PkMZkss8eYyyS9xUzNvnrFcQDLDvD8at7PIcZBeIvKGvJpU03uNDrkp1DDbEZ6hobbz8hYY9ielqGTamkJIYQQQmjCI4QQQoiHgMslLdZiQUitRX0QehYKhH5XCOOz5D0TT4V6RgzdhqRk02XhmZCqQIi+xD7DYZn7UJgpb3KVf5DuEGprx5lESVxUzs/Gdgcn2+ZWlqvOb+WwOcPsdgehuacDk2zRUXTtenYUPfpolmJYh8qxjN+x6j8kCUQSSmctooGOIrQYJg7k63hQvI/FgaOix36Ub87gOrt6BhkLibIob52dUdJDrTfWd0IbPsN7H3uvx/L2s5+V97mWE3R5yft1JBJlHIR44aYc23zOHeUAShdMQoe2TFmqoD6La4mSFvpyqIWG5GaI9VcHQkc0Z0BmQr8rIFVWa7p60F9Yu4uuEH4AHX1Motry3nWTr58s8SCz56ENpvBxcMvhOVSQMorgPuQYCak6TcvwBTIPlkGSopQE1w2llRpJ6Cy2sS2Srd68ibHwHGME2xKlVTqbIMEMdGON044fSkVpTsY6gaTF750gvQVnIr9buT/7Kc8T72RGSTj0QmLeIP+jD7ErI4toogNyiPeEx03BdYmDMeEva4l1015Jjq2jUa6DcxnfiUxqyySdwe2lxINCCCGEEJrwCCGEEOIh4PLEgwgtOxLjsY4VqspbOeawKaNuIdTEkCtXf3NpO1aeM+Ra0SnE0DVDbgNlrxh+TnP/outqpmZHx5D9OB1G5HZwdiBs3kH2Ob+ZnVlMPHiy5GbY5r28fv36xfb7vM/vudhmyPLxG0iGiNA3E47dglx342aW61jPqqjgVMAzZ4LAGaOcrZom/LtZI6yPcPEVyFhX4EajpHXt2lXsnyWtigktg6SF5FuoFfNejz56sf3Yo9exDyTdE4TNizlJC21twP0d+ml3TAqOGITfKW8V0/LB2MKNRQkM+1ShBhCO2cXwM8eaESH4Ec+jmLEjtZDxgjwd6mQxbI6abwP7OyRWygNB6zuQ4o4EZfyipNsVYypdk3RgcZ+KTi7KI5Rqp52PTExazdRCHIKTjzWQDhyxcM5tUd+tRZuhXMecrX03LVmEAQxLGmxmvAi14Sh/Y5fhBM9z6OlqxP3Fc42l/NDe6UT0aRmOYxHvexDMQigD9Qvx7OsV7kmL4xw8S8qkia4zJPqrMJVITFpKaY21tDh+BYkKxx+5LIIuO5xraL+3j98owiOEEEKIxaMJjxBCCCEWz6WSFqUYhoerdtoVUCDUtEW8suyZoAhOA7x3hDOBK/YZ6u3D6v0Z2QchStZtMTsIx864uegoMoba6PjAccJ7cb96ODvo0mrhWOiwHe61nQZKfxXu91UkHnwWkudVkICejVB0B9mwg1x182aWtG6e523KBhtIg6zJxoRToVSX0+UTmyvdI3QAUdKiDLaGs4cyFqWuBnXZGtyjVbhf+fhXcZzrkMkaOIqKEzzQgS44tKOWLhU05SK4bvg7h30Z9XDowKBTiiFtJvmkvIVz6DEObBDqLw9qmbXoI4lherQdOjnTLdbMQngcx2SyULpMB8rWTFRHWQ1tnNLCacRms6bJbZBj3sgEgxg7KSWzfzHhK7etmJa96Hxju+iDI2rm/lJVamNCRiY67CCnDjwu7jGT6YXPo0srjN/5s+jA4ntpfGs7Spo8nzk97OlDNxb71Ez5vvAsw1IN1i3j8UO75jYkMFwW2y+vlklHk2PJRhHvCZewcDyeS4YYPmXm9vJ7tsPY34d6W+xt0wfid0BZStISQgghhNCERwghhBDL5/LEg5gOJYR7e4SfQ2iaSYA6uAhY44Nx5rDyfNqlEJxZxfRK+zKE3KYTqe3+Pb0ynAkGQ7LC4ByiGwv1SOiK6WbcMrh3YZ87kOWOCR0PdEitIGk99qx8neurOXkeQ8IMG7ehTthm8vVhJvze4l70PWXFaVcIw6lmMaTOmjJryFg1XD6Uq1Z0Y6GuFiWwFV6nRMU6XKy3RckthKP9+EIIw8DbDaRBSAYt3DFMKleU04kjGTYP9YyQLLSYS+xHewkcNKw7FxwVB/F9Jl8b2LvpWqFzaCZ3nFOJo1xFxybfgHMKTpAZCYxusmMSyinhnHr2NTrbcKEb1PfikLJaZemVJlgmjCwocw/TskHPRHpBouFYfuCIxSPcbqfHQrZP9v9wnCBXTcts8XXWipoea/j6cAJHbHAm8fxxf6MbCa5nqpCQaJiAcWCiQp8+fkl5OmhgWI4wI+GmA/mIfSfIpCGBJZYX0I6JPsjPoHzch+dBxzVla373z7jv7uB7UxEeIYQQQiweTXiEEEIIsXgulbSY1IjblINYZ8Y6hj4RBg+rp6frg1C6YiKtzVwBrJC0EOH6mWRNZjHkNYSS9AxljzP7TycY5HuZYJFl64NzbJjeJ8hb6fjOATOzrkViNbxOh8i1qwiFNgiVM+wYwsYMTWZpLCR04/2akasYEmXonvIhnVhmBw4IJsOkzFQzcVuJ7ZkaT0w2WM7sE1wYcLbgXLehllg872PAcO8GkpbDbcFrKdDVnTXJmMCumA6h0ykzUKqENFKGOmc4zjgdfqaLcfdHOMEogQdJq5jcJzyzGs5PdH9KGpS0KNFwjIuGj+lEo8dkCwk8yFszrpiUsvSaxrw9Uk5MaIN07eDiSrYRZJvkZxU+/QyDHHRgRWRfC8kqmf9yRq7i2E4ZhFIUXw/uLZ5fqH9ok6/3J3ieHL59pkYVz59qIF1sYfUHx6Iq3uuLz+V3FPbvmTR3xp3M8fcwCjKExIC5TdFNyHbRUp2km26clq74vBPaL8+p65jkkn0iv5dO0TkU4RFCCCHE4tGERwghhBCLx+9kZbMQQgghxIOMIjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRaPJjxCCCGEWDya8AghhBBi8WjCI4QQQojFowmPEEIIIRbPYiY87v733f2V9/s8xFPD3T/Y3f+1jdXbvgAAIABJREFUuz/h7l99v89H3Dnu/iZ3/4z7fR7i3uHur3D377nk77/o7p9yD09J3AfcPbn7B93v83iqVPf7BMRDz9ea2T9LKX3M/T4RIcTdkVL68Pt9DmKHu7/JzL48pfSj9/tcniksJsIjHlg+wMx+ceoP7l7e43MR9xh3148uIe4xD2u/e2AnPO7+Me7+c3sp5PvNbI2/fYW7/7K7v8Pdf9Ddn4O/faa7v9Hd3+3uf8vd/w93//L7chEPOe7+BjP7VDP7dne/4e6vcffvcPcfcfebZvap7v6h7v7P3P1d+3D55+D9z3b3H3L3x939X7r7K939J+7bBT2cfLS7/8K+P32/u6/NbtsHk7t/pbv/OzP7d77jr7v7b+2P8wvu/hH7fVfu/s3u/hZ3/013/x/d/ew+XetDhbu/zN3fth9j3+jun77/U+Pu//P+9V909/8Q77mQOffy12v37eKJ/Xj9UfflYh4y3P3VZvZ8M/uh/dj6tft+92Xu/hYze4O7f4q7/9rB+/j8Snf/enf/lf3z+1l3f97EZ32Su7/V3T/1nlzcXfBATnjcvTGzHzCzV5vZs8zsH5nZ5+3/9mlm9ioz+3wzez8ze7OZfd/+b+9tZq81s68zs2eb2RvN7A/f49MXe1JKn2ZmP25mX5VSumZmrZn9F2b2DWZ23cx+2sx+yMxeb2bvY2Z/zsy+190/eH+Iv2lmN83sfc3sT+3/E/eWzzez/8TM/n0z+0gz+5LL+iB4kZl9gpl9mJl9ppn9UTP7/Wb2mJn9STP73f1+f23/+keb2QeZ2XPN7C+d7nKE2W5tnZl9lZl9XErpupl9lpm9af/nz7Hd83zMzH7QzL79kkN9ru3G52eZ2WvM7AfcvT7RaYs9KaUvMrO3mNkL92PrP9z/6ZPN7ENt9zxvx9eY2UvM7AVm9oiZfamZ3eIO7v5ZZvYPzOzzUko/dpyzPx0P5ITHzP6QmdVm9jdSSl1K6bVm9i/3f/sCM/u7KaWfSyltbTe5+UR3/722e3C/mFJ6XUqpN7NvM7PfuOdnLy7jn6SU/nlKabTdl9w1M/vGlFKbUnqDmf1TM3vJXu76PDP7b1NKt1JKv2Rm333/Tvuh5dtSSr+eUnqH7SanH22X98EneVVK6R0ppXMz62w3wf0QM/OU0v+dUnq7u7uZfYWZ/Vf7fZ8ws79qZv/5Pbu6h5fBzFZm9mHuXqeU3pRS+pX9334ipfQjKaXBdj86L4va/GxK6bUppc7MvtV2kfg/dNIzF5fxipTSzX2/ux1fbmYvTym9Me34Nyml38Xf/4SZ/W0ze0FK6WdOcrZH5kGd8DzHzN6WUkp47c3425PbllK6Ybtfi8/d/+2t+FsysxDSE/edt2L7OWb21v3k50nebLtn+Xtst+j+rTPvFfcG/mC4ZbsJ6mV98EnYD99guyjB3zSz33T3v+3uj9juGV8xs5/dS5rvMrP/df+6OCEppV82s5ea2SvM7Lfc/fsgSx4+8/Ula0L4nEfbjbfPmdlXnJ6nMkY+z8x+5ZK/v9TM/mFK6d/e3SndOx7UCc/bzey5+1+AT/L8/f9/3XYLYc3MzN2v2k6+etv+fe+Pvzn/LZ4RcBL762b2PHdnO32+7Z7lb5tZb/H5vYe+LO4Ll/XBJ+FztpTSt6WUPtbMPtx2EtZfMLPfMbNzM/vwlNJj+/8e3YfoxYlJKb0mpfRJtnuWyXby4lPlok/u+/H72659iNOTbvPaTdv9oDCzC5MIf0y81cw+8JLj/wkze5G7v/RuTvJe8qBOeH7Kdl92X+3ulbu/2Mw+fv+315jZn3b3j3b3le1C4D+dUnqTmf2wmf0Bd3/R/hfJV9pu/Yd4ZvLTtuuUX+vute/ye7zQzL5vH05/nZm9wt2vuPuHmNkX379TFeCyPvgeuPvHufsn7Nd23DSzjZkN+4jAd5rZX3f399nv+9z9ugFxQnyXH+vT9s9vY7uJ5/A0DvWx7v7i/Xj7UjPbmtm/OOKpinl+08x+3yV//39tF5377H3fe7ntZMwn+Ttm9lfc/T/YGws+0t2fjb//upl9uu2+h//ssU/+FDyQE56UUmtmLzazLzGzd9pukePr9n/7383svzGzf2y7iM4H2l7zTyn9ju1mpd9kuxD7h5nZv7JdJxTPMPbP+XPM7I/Z7tf+3zKzL04p/T/7Xb7KzB61XYj91bZbPKdneZ+5rA/O8IjtJjbvtJ0U9rtm9s37v73MzH7ZzP6Fuz9uZj9qZh88dRBxVFZm9o2263e/YTvTwNc/jeP8E9uNz+80sy8ysxfv1/OI0/MqM3v5Xgr+zw7/mFJ6t5n9WdtNbN5mux8bXOLxrbZb7Px6M3vczL7LzM4OjvEW2016XuYPgNvZ4zKYh4t9iPXXzOwLHoQV5uJy3P2vmdn7ppTk1hLiPuPurzCzD0opfeH9PhchzB7QCM/d4O6f5e6P7UO1X29mbgqxPpC4+4fsw6zu7h9vZl9mZv/L/T4vIYQQzzwexmyLn2i7NQaNmf2Smb3oDi164pnHddvJWM8xs98ys2+xXQhdCCGECDzUkpYQQgghHg4eOklLCCGEEA8fmvAIIYQQYvFcuobniz/9oy70rjRm6cuRjqGpckHrEmkAHUpZVWCfMpdRoZxWFnnuVWGfCscP+eewTVUu8RyMeQnNmHNpHAfsx12wz9Dnbbx3wIcMOE7Xtvkw44xUWHGOieMM+Tgj3vtdb/j5w4t42nzjyz4ZF5df53MYhvyHdruZfH1E4mOmfqzKJh8T18Z713XZkcrnVqKNJJxcwv09VF/HMX9GWeWmPIbEzNPXxqdQlvmzizL/pcSzKtHemO8y3DucnxfTj+2V/8NPHeV5fsN3/vDFp7Xb3O56tFnerwL3t1rl5zSiLfcjGwWeAftXOCb7YN5/6Hu8IW/yubD/mZk5Bo8itCm0C352Of0MOEaE54rr52ezr3H/puEYlNtWg+2vecmnHK1v/sVv+8mLE+kHtnleG/oUzjv2x+nxZRxnjom9R7blcbqPc5wO+MGtwLHSyLbE4/rM9vRxwz7owexrNb4vCuxf4Nmii4fn/PIv/dijPM9Xv/63Li4+jOu8J2HMRZ/Fc03G/ae/r7bbnIWD31eJYx3uT4mLL+7wWVZ8D+7jGPp2OMDk6xx/3Xh+PH7uX2zLc2NNhf051nzZC583+SwV4RFCCCHE4rk0wlPX+ZcgZ6EFozeY8YWZIGZ5VZE/pq5RKJe/iDEVXDU52WONX1T8leYFf4ljH8z4Co/zOUZ/QoSHv04xI+fsue1zZIK/hLsevzrCLxleXPjJOnl+nP2mo/1ujNT1On9ePxMFSTlaUOJZlSV/nU9HexgdYduZWxbP2X9V5+eWRkYpZiJ8FiM8/Fs4J/y6GfkLA/vwlz1/Pq1W+frD8WeiAmnml83sr+K74Mbj77rY3ra5bQ59br9sy4yaNOvcDkZGGfmgGBGZiaCESBfGhxjh4S/9vL3tDvND5r9VTW4Lq9VqYo8YveXzsDT9y5ER557nh2vg2FTjHDi+rOvTFPru8NxihAc7hTaeJreLYrq3DYwIMXqTpiMKvKccvvrwU37e8BLuPSMV2IfPkO0zjbePAvFIJX63DyMiAeh2I575yGOeoG9ubj2RzwGvjzPfCePA7yI+g3zObYv+gu8uRnc3m1zIfER7KnFzC0Sti5m+XBxEp+swPlJCwX0P0Svsg+9+D9/f02N3gb5WhmhPPiTbL69hVlUBivAIIYQQYvFowiOEEEKIxXOppMVwsqW8Xdh0SLSizDQTTq6rLHXUDHEhTEVJq4HU0dRcSJi3V6scok8+LSuYmVV4fwib4nooD9y8lUOEGyxI3naQfUqE8hGO4+LRIUg3+foDHWScE4RZzcxWq4vCuLb1fJ0jF5AxGomQ4jig/E3PBXQM0+bNhIdehkXrjDNTGsLiWZwz2857LLLD53HxeI9QcMM25pTfuKCRoV0ujM/vZcjWC8odeJ4M8Y4zktmRGPu8oHzEQnCGsoc279Nz0Wqb+xeFzT401HxdXk0vVIznw8XoDKfj2imFog/tzoMLafNn9z7dvvAorUefpTxQBsltWupj9L3DAtbVGmMQtr0/Ta5WShY95W2bll+4zTFvCPJWPn4UoqYXPM9JLpQ44qJatp7InCwVQD/FJcdniL7jB4IYdpp82cdi6mXz0Kbmr+Hp0rf5e4PX5WERPeTJnouNuYCZfTnnxk3oa915/qwO31cDxgR+hxY0LATZEs/4QKocg5yP17kUgu2C7RTLKChplRXlY4w1A75DKcXhfDjWh3HWbz/OKsIjhBBCiMWjCY8QQgghFs+l8dn12dX8D0a5Qj6TaWmI4WSHm6ZGrpYzhNcahK8ayD4Mx51BulpDbmP4mVHZw/B7UU07LLga/tb5Bn9hWDefB2WpDiHIDqHGLUKKHUK0DN+FvEA0mpxI0vISEiXcHHRFVRX2oTOrh6xhyM+Dax4gy/Ge8nkWBcP1dH5BGqUKEq4g5m6x4K7LEokHtwnzuNBJwHg/3GXBdTWTYwdh1L6YcQWFfDDHd/a025v5HNrpZ9AjjxLPudvm8HgPCaztcC1op83VPA4wLN/PyUTMPUIXFHNtjRQuLSRHKZijp53OBcWG0cNN2WP/4ECiY439ixpun5/T4OjXBjm3OpGkBYkv5CsJSwPYMaYdMjaTcyXkfQk5edCHggw73T9STOCVz+1AtQrPyqalk5gXbfrZBjftjGOL512NlPSmJa2QY2o8wVjb4TuEUg/G0AHnNvTM3zYtsfF7toXDsT3P48CA/l4EJxOfPd2UHE/xLPqDcRb3uqP8BgmJ40JiPquzfNwa399Gh22iQ3dang/y2cA2i7ZcSNISQgghhNCERwghhBDL59L4LBP/DAPlALpdplN5MxkUy0PQgXUGWerqOofQmdxrBTnkCvZvIIeFxG7BpRXjrCk4cPLmOOI2IKIYkgHS/YBkg+XAZHtwNY0MI/Jjg18A78XqeTsNdZ3vXzgnyFLBVIPn3EHGKkeGDhH+DEnmGDZnSngksOQ2JENKSTEJVtQoKVOUBkmLeR4rvh8hZVw/r9kp9RXTIXSmtWcSSn4UE3KWM1Lq3dB12ZHR4/mNlLQ2+ZmlnolD0TY7hI2RjLJYneX3pvze+iy/TrMLn0XfTSf24/2sy/hbq8A9DefHhGuQ7nrIb90mS3TB8QKpgNJIg7GGCS+LAm2558NEm/CDcP+RaCHLUT6lUzJkfOU4h+M4S4Vgm/0xJC2kPMv+NCBxLGS84JSaVtKe/MD8GQMdfOjbdGDNlCZgu5jxaAXrkPu0gyfNlE0ZhsMTv3va85x4MCR45fcPm/+MOy4k18UN4v0cKYf1uQ2FUj2QS3v05VCegxJhH+VmLsmg9OrOtsl+zmSALDmT31sxoWiCZBxKRuXP5Xg6hmPieu7ADasIjxBCCCEWjyY8QgghhFg8l0paTHpFGSvNVDFlzSyG1Oh8oUzG6tqrivJWXs3NZINrOEfOzpDQyKZDl8OBNsRQMVd9p5C8CG4xhHK3OG/KGCUTgyE0uWpYrwhJ1sIUk+FLhCDnEnXdJRWSyTUIdzMhI51mI+QEhjyZJDAkQAs6ISuZM8EgTig46qYrfseaSQcVtvHcUfooJjqcLqYbwv2sih4ugQ5EOq0S3R/Tz81DDZnjO3sKOocSJS1IQEhOWHRMYoZ7vc3vZeKumnndjNIh3HQ1E4ZB9gpthclF8zHrKEqY49kWkBkotyZIWqljIsx28nWG0EN9NchhjiGwKBFCZ9K6UOfqNH1zi5pITgl0powRb18R5MGZxIBhF8gXGBRDck3s3kNaaFgLEPuMB5ZYfl+EZIAz9Zemr+DgX5R+KJOzIjclVEqjlGko75XH/83fbm5cbEd5d7oWGq831o+ipE4ZmuMyDo/nzc/dUNrGd1cdEvlWk/uYmfVomzxuUU0nreQ4yLvboz82aFNMQBnkWY7FwTU4Lcm2rWppCSGEEEJowiOEEEKI5XNprJ3OGWoRsSbRjLwFmaBySl10u7D40rRMUCHEx/A4kxLRIRBcAIdhc5wfZSlKbkwkVzLZIMLMFd0POA/WQWkoac2EcWMux+kEdseEshkdKQxThuR8M3WySoS1KXGkxDaS92eyQYZm6RzpkQyvggRWQ6tqN0wKeSA54Z41dXYS1XU+VstnldhW4WwZp6+Zch3dJTWSOYZkg5B7qhO4tIoiP7MS8pZjuzI6Vlh/J4fcrYUUBRdfucn3oUmUDummgtSBaw+SDO5bVZcTr+5g/bOS7j26tOBkqqBX06nCcH8PNwt9J+OGEhiux3OfLdasW4U2OJMY7m5hrb4CbbBhP6K+xTpDvPfltDzLf7AeFn/yFjMu1vByKGHFthDvSwd5Idatg5MVY02oezajYlG+YL0tfo9QKUlsI6FGFbePL1Fubj6ejx9MbUjgx/PHtdPFHCS5mWsZ4JriPWF9Pe7D7yin2yskXI33ZNjkPhWd2NPj/RjWKrBf470j+jLG4hbnxzYelqcEwx3lrds7KBXhEUIIIcTi0YRHCCGEEIvnUkmLkc8Qfiymw72Ma1EOKhketenQZY8ETR0kliiBIawXCi5NJ8MqDxMR3cH0jrKPw7VSMMlSmguVIoyLODCTCjr26VnmHm6J6g7K3D8dKLOE2j0IOzJ8zZB1301LcXyeVOJYcoh1rkaGMrF/XTHEyxX8CPXT7WZmVU0ZlLWrIIMwiSGcVo3jmVByK/I+wZmF1wc6eEKbz/uUcCAmP75LKw3n2IbDh46H4NiiZAKHE97L8HONvraC5Hc24BrZn9je0Yd6fFZJF9BBprqOfQHOMUdtrBIurZEhfrTldsvaW3B1MeSO8x6Z0M0hB66QJNF5zaf5jdji2gqG77lMAOdahLF5evlAwTGS0liob4YxbsZCGZyrJds7Nd/4PKvgauRfKG9N17oKNZSYPJAJP3tKdDg62lg/k/CQnzaG148Da9VxXOqYhBDXzjbV03yJe9rSlYgbuoXcxH7ApRY93ks3ZFCJKBNZJDyDmcSRbGt1g/6CQb6mHE75CWMQx4iE78Qi1B7DWMFEo+9x5u+JIjxCCCGEWDya8AghhBBi8VyeeHBmtTxrVoyhTtLMSvsZFwFDlJuO9ZywahuvN5AwVkhOyBBtQRnq0FER3Ab5PVuEk5mckNs9S9LzdUpUSGgWIrwMLRdzNxVJqd7Dw3IkfFqK4Qr7AaFGSlp0XXQInZrTAYDQJOPyQ5YZ6jLf6xVcOwNkrG5krRg8/ybeFyZBo/wYNTdIZSPbHkK+KYeFG4RjWWcp4fjbUGpm2sISHq0dX6LsNqjXs8W9u8naU3A7odHWkCVoUikhaVVoBxX64ArbayadTNOfxUR9IQR+IDfXrNsGSYA1wOjCYCh7CLXE0DYhb5UrSj3ZCdPTyYb3bje5Vplj/9VZ3j4ubLR0NRq2Wd8K48VMnSj2iRIaM8fLAfvTfcmeVkBKY58NueCG6JBJI10/04niYi0utkkmDMRBQ+ZFjMesB4fx2MP5TbtPxxO47ga4CVOoBcYxN9+fjm2c9Rux/xbLPAa6sVhLiu9lXTRIjw2Sz4YlH3TPHVwPl2qE2lUcO/AZFWuAoZFUrLfF5SmQ3oN0xZpnHb9n4b7kOCCXlhBCCCGEJjxCCCGEeAi4VNJi2I2J3cYZlwqdSaxVVFFKKaZlgg4r6p84RyiaJ4sQXINV+jUSnTH8OhyEKxkuY/i2pysAYdYO799CHmgRXuwROgxJBSn1QTcItUKY2LCmo+I0khajzinMdafdTkUxHR7ms2INLNazGpEBjIkE15Clmhrh9xWdPeEu4ThRBqE7ozBKgpBcBzoDIKFumWwRx0RSTV4D71FVUdaosX++AXRyVSdwadG9xjBz18IhgnZdJ/YX3JM1+k6b94dJya5D5ruKPrTCs2FitNTTZUUHIO9hTMZI1xb7DnUTSp09Hn5PeZb9ukO/w+eNuJ4NFRa6AxlO73PIfbh91PxpkWYSkrJQVJChQxJRn9xeBXkW7sMZaT9IWiHhISWtYnIf1i0zO3DRsfYRS1ox2SrlYH5f4Ji85h514niPKFfRORRq/vXhoduxGTs6BfE6b3wPyY+ng++EnokH2d4h6bDuFZ1PbtNjN5V/JnU13NvDJRVcwhBqpuHzEsY+thcmJ6VDmQloWWNv7Pn9TdmayRZZ2w5S+B10TkV4hBBCCLF4NOERQgghxOK53KUVQqjM1oWdQsl7vJeygtGNQ1mCCaCwOruN4dGLYyKEVpzn7evXruQj4nyYwHD3N4R7V9NuC4aTO4TmN22+6PNtPj8mVuP5MUTIUGxiaDXUGWLc8TTz0B61rjq4KIaRz4T1W9qJV6NLj5Y1ykEDXDsVHFsFktiVDZxDdH8M0xJjcyhpTeebDEm0xoHnSnkLEgzkpy3dDUY5ZrqmG9u5IZmhYX/349fSWjGvG9rmyI/CzVvDpXMGecdDQkkkMETfqVgjDnd6HTJNok7QlgnQmPwN+w9RbqY7zoJUQqcGZEjU2GIiMtZtu3KGRJsN5BC41NYI61MGWK0of9OJGseUY0G3Z4m2yZC9s/7SQClqxhXDJIHldOJYur0aONnqioljp+vfsXCVI6mpmVlHJw3H4SDX52fe0QXLBK6UOoNjzSb36RJdfRwV6Chkcrvju7S2t3Ktuj58V6JG5Cq7jNkvulD/DveEzj3c9zE4IqkXMgkuzw5tJUHO5pKAA5XP0UaC6sukndQq8T1T4qENGBe4XIKPiTXl6MBiQlVKeh2O3/WStIQQQgghNOERQgghxPK5TeLBkH4qvx5WYWN/hOwoUY1wqSTUGOLq/ZaOKIRre6zIDjVTnC6NHAY7O8uhwt7mXT0tZIAyWAGm9+kQOmyxPczUaAmHZBI6n3ZjRdfUqRIP5nvf9dnN08LxxpuUGEbkinzc+4TwKuU9R22sDjJAghxUrSH7VfmYNdrLSInpEknL2N7G/P7NOZ4bE0xSikUD2CKJH0OwNVwuVUUHGl1kcAIxyeEJaqM1uF/FFUgUkCepVK5R2+ishpzLhF6Uj5D8j/Wpxib3rxJWLkoMI52bGEM2cGyVB0oCJRQKlOH5M6ko6yp1OFdIGokONKpvlHcayJxoE6s1rgHXWRTHl0DMDpK9BUmLMhbOFWMkuwXHsgr6Q4F+XUNurZmUDv264jZXM6C/M/HgeJD0zQvK1XTz5X3oMOJzpnzDJLTB1VWw3fKzcUzWjUI77OFG5Nh8LJ541zsuthPkndUVLr3g2A+JfCZBYj9OJ/wLX2rjtCzIB+gzyyUGyETDEGXbkZJkmn5mlK5vov5dh/Ge39kcN7kegYlDWaeSGSg7JHbcYszadLeXmxXhEUIIIcTi0YRHCCGEEIvnckkrJKTjEnnsQ2mACaNQs6NAqD9BrtgiDNbhvUOR99+m6dXcTFTljGQh7MtkTWZmW4TCGB5doWZSjRAqw4IOScAgaTA3Hd07I8PyXBkfXG3T0qCfKPEgZUbWOBqwzfvSIZlYh+Rro8F5g1BjDZ2C9XAcThjk27IRsfh6zSSMPGdsHyaSpOSKxFcjEs4NW4RqmTwRx2khm1Le63iP4J6o0K4qnBNrURWeZaN6OP7viutX800akKyrZR26Cs8GXX21gqy8Qdj/HKF1uKZCyB3bdB/yQZXsKyWOj5D2oZQwBhcNJNNQtw9SD+VwhNY3qNtmkP0SnmVwGkF6bM4g78B0RHm2Kk/VN6dD/OFeYJvJ3UoMQgXHLLTHBpIs9y85BuG9I2Qi3mu61FgX8TAjYzlXGwvH6lFDicnkSrpaWfcLsss4TLt5aLrqZl7nMFIUx5ebzx9/Fz4AjkgmA+QbsNSAdbIoaYVlJMHsOF2bkfsURkmW3+PTSf4Ki52T7SjU4eM9TWGgzpv4fnCb7o983sHrFyQznB/aQXsj17zb4Pt9DkV4hBBCCLF4NOERQgghxOK5VNIKoWlKMayb49Oy18CkgkwGiBDclnFG1u2C1JGY0Iy1gRDqHnCe51yNP8TQHOvm0P3VM+TXTa+GXzVwtiDJVkjIyIR0lKi4D90soRYJQnwnqO9iZtbDkdN1WN0OZxITSHUIod/aIJlcyqFD1smiTEF3Rc8SMgzH4j4muGXGmknSkMTqsMbLdjrZFYWvgfW9cK7tJodFtwiX3trC6RCi9EywOJ1skf0ihH5P4Lq7dgV1u9DOt8V0O0p49g7pMcF11DG5GfrgiL7ZomHf3GT5iBIzE37egutiwySEB/ekpfMP58GkfwNquG0hy7TQgxEpt6Lm65BD0MarIrdB1hZq4Mxq4Paq69P8RoyJLZlIEO5A9IUaY2pBOYIJ5yg3o38E2QvaLmusJTR+1lJa1ZQ3591OPO9+pv4SpY8qWFnzJh1bdOqEek343DRyjJuWtJjoryqOX+fu/MYTF9v1KjuzuGyj4fcm2imfcZS0sAQDmj9dfEWJelaUrtBnYZgL22XF98Y2XvE8Qg276SUMBROMYmwdIUWVkMZD/UtKuJSo6FaEe9YwBg2bLG/NoQiPEEIIIRaPJjxCCCGEWDyXxvNCkrwg1yAsSSkKYbQCIbJxpn4W38u6IUECguxRMBSPEHrLZEoI641lrGFEp5WXqPUSVpgjORqdEHSsIeTMcw0J11hLC+cXHCK4FyWdbCdIhmUWHTas8bKFvNWzxhSu8xZC33QSnLHWDZNm4fgN5MBijXsBK0xCqJyJ3lJIQhdvDMtk8fMGPgd8NpNa9ZRZmRwP92IM94IurXwzaoTZVyucH+QXSnTHoq4h+9AsBcdWh33Y6no4bbaJTkkcE/FuyljvuPXui+3Hb+R96pISW/6083MkCUOdnOFA0irgECtCsjLIL5RDMQbxGuorkJ7XjNmjHVGSZBJC1M+q0QbPruS+uVod39VjZlYhoSMTCVYYX+r4oPMmHEt0zo1IsDdi7CyqaYm9Ls/yPhzXIIdxqOtUAAAdb0lEQVTSKZc66kThcoLDl1Iv3VtsuOOMBOOsBwc3LaXuHg7SNMKlF5KosiYXk+geX9Jqb2VphdIN6+tZnc+5pmyJfhSTE2ZWrMeIe8jErCu6LHk/ccyKyT7ZuQ4kLSYuZB0ryk9cbsJxemA9LFwF3a0pUZLNH9vgvIPDGtslZXIkS51DER4hhBBCLB5NeIQQQgixeC6N53FxfUyYB/mJBwt1Oug0yNJFxXgtQmeOMDhdNmXJFezTpxsSJFI+KWLYHMFua64g7MZwGcLuzKtVVAy5B19Afi9luSABYgU7w7iQQ1IIX57GpRWSxrGmGe4r8vRFSQf79LBa3cQbxvA88zVfdSQ9g4zlCKlW6/x0qobJrVjPi+kCzYqGtavy60yG2KM1DTgPR5iWzsE21JGBPAonm6N224rSLWp4reHSSmfHl7SuXsn3kYkTB8gH1XY6aScTtW1HyCHoID0ko26T99/cuHmxXYSEn5DSeHy0jw0cFcG5Y2YJbadivTXc3+YMbQdqdYJcc7XIrhiONRUSW9JpUtWUlfMxSxyzKpnA7zR9swhSBt1PkKJwy6AA2wrj7hnrJnHpQU+XJWQy9Ds6qFhXjZJUWG5wSbJUSlFlSLgXCuBdbLG0Eoe/4MbCDehaauyQNXq68SDVY8yqGn4HnUCihOxT4L5XKcuWwS2Ft/I+sP2yu8DQanXTTG6vOZ6WlP+wZAPPMsjIB/dkwL2+Fep14ZxWGAfRvgZ+Z3cY79HGRzwzSmDj/9/evTU3bixJAMaVF0kzc2LP//+LG2ufkUjiug8nwv0VFtQ4bCpil1v5BNMQCXQ3mpzKysyggN5vHXENzbQs3ENWeBKJRCKRSDw98gdPIpFIJBKJp8fnLeqLnfOqq/ZVSqEzn/NVRx3PRQnQH0vZzS5vy9tnqZ7Gsi8KLw3WVClsbscSoUWx4Vq6u1fKYodgpkRZ1z+GNpstA4cMHMyhNGiDxtMksfmiLC3HeJwtTVIq1hcsZOgw5/AJ0hc1ao5zW8q3M0XbaZVWKuc0PVQkdd0m5MPEvB7LvHVYymUOLzeMqVAnDXOhMWVmuIWq8d8DUSJUDs2HUtWnEuYLZHctNIsZXqq3elRKC3TAgAMnzGalX9jINV+gfH/ORYEyX1B4YeT4/lGep9uAkSWl8WmTvTSaSQa98+PHtz+OX2v2DvN3jmVNNdCN57asqTBe0gnc/xGV1omxI3qsOoewn0eCPcy9kL1DmryH0zryvLQqXlSjodjSYPLAYIz4tgVDO2jFetnfy9qNsidQV5qtBuWreyr7aMhAZN2yNw+XC8fldTPAmsrx4h5U8n5B+4DfFQfG5Qgt0/F8Hdzv79CHqoSbyT2R550t8Mj340EFsKo/5jXmQG4MXtlo16BK5iSyM/0+ttXAHLVlxLSUjacle2wK+YWsGw0rpUX/RPkmKzyJRCKRSCSeHvmDJ5FIJBKJxNMjf/AkEolEIpF4enzawxMcKWv4PjhjnSF10ex6eHUl3fCJfUffBtyrDpyG0LX0eehMrDzOHgwlulUV2zA6uOsJCZ8ujr18swFnQbpccEOOKN886X6rrI9rNTx0mbfdR4+B/TbDTYmwganMIXyqPUkTgYuOyzSV9xzIfZsm+hNWRZj7x01tr1Y549DH5apkebBHgbHvlJ9Pv/9xfLl43fDSytuVXRIgecAVt6evzDWlJcI2jO8RONCr4yD5zM6r8ltl9T5f5ZTbVZdx/ofz91pefyes7+f484/j3+mJC31qBtNOsYdn4L9PNs1gp611w9uh9PMcXhjrF3oUCFg9HJwP+idQZb9w/ivHtBqG40fCPjpluj09PCEAVQsI5tz+pM51oRS/s6+knN/Wrql9d1576jrW+KGLUmb/RvsNXa7V1o+c4/6Kejn0xgQXfMbIvqDOPhYmbuJrb14e/2ye+T45+f1osPXV1Fa+T5hA+yZ1WDHktaVvtKFHrj0QkEvvUM/3cnRatuc2zmXn2rTpjbUwBxd/gqkN6f4oXwru0Y3BwaHf0TBbrs8wVCX62cOTSCQSiUQikT94EolEIpFI/D/Ap5TWQLmsxVZVmWKj5Bzn2wOls8MR+bElPmgpXU51jOwoodXSB1JalWX88j6368Z5kXKqTqUzJbwZuatl04PUyAAdRMnekruS7jm4yno+7sWU+9dNuf9RkJbyWCqmQ15o4J5uvgeoyCBBRM44jzppUrqG6poHz4dW0p0zBLtuAicry5zI3Zm366Xc58/fy3p4/yktCbVaSYOU113PR8vCzOFq6RdaMjpzPwadQbrM5aCTKi7lPTS01+nwttU+RdFXOLhWxcl44v1/GwuNJYWp9USNE/VEqGhVVVXL/zu+ls9o0YH3/1ForLd/Frn69x/QW7joHg7lPXtpLNe7gaGEvHadYye98zXJvmFvc/9DZq/jc1Mpv644Z3//MjD0eHT9Qu2G8EXpFCgU9n4J6eNmift5g7YXhp6y+EYodu0LdC/Q8deNpOcelH637q/K/rWV+ILpfHHN8/oVSieYGdcXXi/3GNpF4LQWqP0ja2UZXRN6ASB1P0OrDVrBKEuPjvYGhl6utmrQ5sBA+oi8/6vQ3r//9q/yGThQ2yIzQecqMw8OzNxbZ6Dsn3g2s8KTSCQSiUTi6ZE/eBKJRCKRSDw9PqW0LFl1JJYZ4mnoWAv9pBpLauD88lrOoUynU+dRKkE6zDogHfgDKihpuMaaaxUVP7qQBrfoEI637+LYBDpIRVU5ybGbOcdgNoMVDXUbb78OQfsrkFpT2XEItKGhp5a1oVBuqCikRxjflpL7dC3/4wZtcD3iEsp8dLxRB2U6jrFkOV6lzcr/+/2/Snn8t/8sZeThyv1AganMOgcaq4zL+bhPY1UooUKIraqH+vH/rqhx1F0ITwyhjWG9G87Jeue5XlVfqtDj9ZrUw/6V0FkDNi/lmT2/leOOgMGPS5mjqqoqln/1wjMvlfz9W9k7/vHj7Y9jg1RrnGflQ3Rn9fmV6mv0Zl8MWTTM9AvCJqtILfrcGbAcaAqUTFL3CzRFD+Wo8m2Gwh2hfGdclDsUsYsO8rou9/s0clVVVc0amycDZHE4Z35Utbr/6dg/T/uUjfPmXEkTjlAu7rVL/elX4F9CD5W6sGfZFjBeSgjvjTmrw1pT0QytTOvIfDKYuoz5FbXx4b387ctreYZ8z8XvruB0XVUD73XBRZ1lUQ1TSJ0u5/8s5//++2/lb5lvXcNdK6rvgos0e1Zwt/8TCQVZ4UkkEolEIvH0yB88iUQikUgknh6/qOftl+U1QZJmktJqKZc1917nkzRnM0DsqNkgJVT5k3Wlq3+yXL0xqgtqGWgmSsgrFN1qGVymKwQfUjbHJSvkizaW7DDY0pSJ42GIXfKPgkaMteoizbqcB2kZ1RUz82mp2EBSaK/LQuc9s/7OeDWzCgxVCPs0UVVFs8YrRl4/f0NV8M49owTqVJ5QL+1I09T0UuXFMmtUKOWAeSIrYJn2jSr/DqS0LP02IVgP+gXqpkf90VGWbnwfKJAWd7oTNNZEub6mtL7y2L39o5TQj1BP1yHStnNwDGXOeZ6P0FuvL2U+VKqoWBspvzfDPcqUi1ApqdFZULw8fi6rahuMTJne/FpeX4KhI9TuUsZ1rqWe3e8M9pR64j2HfXrLJNWBa5g3azzoUqWrOPac4YpKCwpl4StKQzvVvp00PK0ON5VZ/O3KPjB/gepOQ7/LzXFR9Vr2qNtY6K2JOehQwzoHR76jTlDtrVS1CuMXW0rKOPe6bhr8vWGGAg1pGDDrKITcajz4Xj7v54d0JiotVLwTjrUN55xPmiTadmDgb1Fr3kNWeBKJRCKRSDw98gdPIpFIJBKJp8enlNZCaco8lJV8myDN4ViDqqj8sVueMrO1216aADURZd9hpFQ47yszmm0miGos/exCSdhyMuffOcdytyVFTaNU70j7hAwkxyVQZo+D83kvp6SR+mC8F2jG86kYw12vlJlZCnbwB9ZgKO/5878ob8NoXX9CY/R280fZnfP7/n7jmLUxoSiEfjIn7dzvKwGP3KdU7FxLaZlLpcmeOXSP/3dFeFyQY41mvq0a1UHhmZ+kIV23/wwiFqle31C+UK7vDsUI8PS9jOf3fxY11fG1vD5slIgD7zV8QPteUG2wvs6hlM8N8Wx+sKgmKUDWpuoPVU1N5f5SDtfm10qQv4KRfSHQbK4d6Rpo73qCuqvKuJ6CAs0NDxpeCt82gXD+vprShTReisFcVUXFV7gHjVrZ8xooMWnvWQNXxkiDOn1dNdCboTdX1JQTf3AZH98+oOp3lvZjfM0O+7hKb/n9xZh05RyNT8+3cjxgxqgJ7umlUD39UfND9nfme93UQZZAXTIH6z712jLutm28Yza6QA03HWvCtghozhnz0wMU9gm67rX7Xv0KWeFJJBKJRCLx9MgfPIlEIpFIJJ4en1JadmdruBUMiyh32V1/MG8LBUdNycpMEwM4LIOF7n9q6yuvr5Q3G8tsG1VP0GhZ7pSiCpVcr7V8Xk/ZtKEmXg/kbY2oItpyP6pTLCc3MVyl+grc/TzKvX6ypVlNsCqpSJQELfKcDmO/FZUWzfzBMHKltHw4YE7YqYLblJ+Z358/S0n9g3VbN5qjkbuiwmCCQj2oECwUjCZmlnUd0y6UiKE6N1TcQwBdE+lmy8Ocj/SihhppOLZUbIZVC328cl8XaSLWxxHa6+21vP/bj7JW1jWOyfWDnLOe+XvlOlQTQpOoIA2KOLLaBlVXrLtaJdO6TwE1Zgt9TZRWMNhb79BY0jsj99mwX3YYhIanhb1swPBUhq7TSJBn32yrEZrhcPAZj2Z17p2a0KoEW+60H/i1oJGsBn2z5oyoKWczD1n/qqWuqIJuXxCmdYIKv5UtpHr/QE3McN2Yy4vGue6bt3IzR+it+WyuIS0oXI/mfwv7ZI96OrRpbL43Qwaj57H32xbSu/GYbYnCayKP0qmsNQXlj6M5sK0zGBz/iczCrPAkEolEIpF4euQPnkQikUgkEk+PTymtkfLjDYqmoTTVQDO0wWDPnCPMiiitm9HSUsa1PDpRfh2lkszQsJNfZdnGDMvOeLkr1R8tZf3LtZT/NFzS0FBKoIX2kALSVK2NTmIcQit9gaqnqjaKN02nUBRNUyk1TovXQV4RY6+yxYyaYOao0ZvqMIwHh2spu0ppto0d/4Xq+Pf7ls++DebvlHOOR6lCxhj6qcVs8NgXRUNTS7tI6UKB8bfO4eZC91//G6hVEa0Dr0M3cj1rIw2JgR2SJV8/Hlmb0Nkj9NbE35pNd2JNtBjh1WNZW/XG8K2jCH/WbJLrhq0JRmQqJa/QBusRShYaw7wpM6lU/nRsCvXqs/w1CsqRfUuWBfatOmAW2h8LbRLYcBRbKtOCm5xZSRy35odBMYVsKPOTLqgslzguLvlZtZx7soIv2xWYz4nrnr0HKQ6+xgZMKwf2r0GTUi5hXB/fPvDtW1EmSpfPczEYvLgGL84Nz6a0O4Ol4WNrO4e0INcjTSQ15PtLQdYbJWLNfteqNGMuNVIcWAvhu5w9WjNKr0PF6RmjUnPC7h2fjp/+nPn3+b88I5FIJBKJROL/OPIHTyKRSCQSiafHpzUgy/WWDRdKi2swHpSWkuqgbApLoCFhULtQUoumRyp2uE6uudVAaWPgt4Sub0qlVvBUaZktEwwDUW81+x3svk9Qo01SbhppWer9GpWW3ffBhJFS+UzOjAaIHXTd4YCJF8Z+1aKxFJ8VytWYyklvzrwPY7GYefY/fp/TrQ/lZpZNjxmgijLNtcyp6Vozs/ZL6Ga9NSzohnFsWV9bw8RHYKaUbXm4YUx78+8wEuydP6kls+CgN46d9A70MRTYANXTU1CvLV0XRivyU1VVNVARqo7kJ0O2mwo/M/+g95q6HHcoJYk8i2pN89w4fUIhs73uR+FfH2VwGvbR3vuHuuqhWxfUkW1dnoMpmF+Wv61rnykNT6EW3B94DqRWpk9M+zwvGAZqSGqLwiiVwxtJywbDT455lm9SP6yXcZXqqnj97i38Zfz48aP8xyLNpEEomYLmU81lHdhG4jr1+mf2R/eZjpYFFbkN9PSkJhdqaCPSCvtuMMgNNKaUrN+JtLZwjt/FDV/mR7Lazi9F4nZ+K/dz4vWeFpTDKSmtRCKRSCQSifzBk0gkEolE4vnxOaWl6kRTrjvKpE1vdzmfc1poBUvudulXd9QuMyVUs0I0XjOjo9qqnUIzPJSW1JWmV5QazURpoCus6qoUUrXQQhs00jBeX8gY+xoliLSh9xMMCdtSLpRms9w/M8brsk/1WF5sMKJaZjOUUMU0mkqWMyyJdu12XVCG1ZTO3K8D5oHQAOba9FC3IWNslWaVxirn98GsjceJuVXV9ygsmMEto8flnEMvzbefjWV2zco81cx3yFhSKcc5nu81WA6fNCTblM3dR3SMq4NSpeAWPsNsO153Ia1ct6oVKLBAybIR3K7Ss19DN1+5ZzPNNF9rmKtT63NHztuyTyXVkzRWgcaujZ8rBXYn/0/aejsqQaXFHhGuqZH3lwbhZd5z4XtBSqTq+VvG5crau3KtA2M0LI/ntFRpOXR+1pWP/cb3zMAf3MaiuAssH98/A/NnttWBseqcs9p9gD2X79B5o25eV78Hoa7uKKLrP6FKPUpF9ZifSr1Db51O0Ftnjl+KWvF0TkorkUgkEolEIn/wJBKJRCKReH58WgOyMhVypUK5krKW5S5zTwbr7Big9appNPPTkI+Stp/FT7V50dhK87B4e7WUiOIUzpnMJbp3b1BO0jsD97lCsYxSDlBJQRwWpQnVV2C9k5diJo7GiNdbKakON9Us5pCV91d11vXSdeWwxsDP7JPu5NyQGRTGdEuaSrNCfXWWSIuRoCZmSvM0Hmz5W5ULXec5UHeoIZzC1vXcPP7fFQvrfHU9IjuZNQXtPN8sLd7TtY9hmurDBdVVrYpPdSTU7sj1TGTtrZuyd2cekrzyuk97OPdt5/hy/5pRTl4396MySzo83LPqkjvmkn8T72Q9OSfme1WtD1K5jiM0dHgeW++T++c9J1WQjEs7qGj1Y/fNUt0TqipSHxrirXdaIIKCad5XxwYaq91XPrpWP6DDP1jPF9bkGC/7IXh5fS2fZQbWqczBK2N9hdK6sd/5fXLzuWas7mWTrcON81HfBXWUe7RtFPHZDEaEPheMr8ou97tVY0vm/sR3jjRWo+qMc07nso9/RwX39q1QWufTr9WwWeFJJBKJRCLx9MgfPIlEIpFIJJ4en1Nad44DvWVJUEMkMndul1JeO/QcU1IbzQDqLLnvm16JOdBQ0k3x/NVOciiHaJLI31N2tLKu4dYw7ueJOGLSbNOo8omyb6BnvobSOtCVbzmybaV3ypycj4WuMY9lUiHD2FmKjuaJqvqsj3t1+xSY9NG8oUH6TiWC9BMKFkrfK/epEV80wITeY7w077I061wFgzWUDdvcqEfAbDdVFZoljiiqpANVdmjmhjdb1UD1aEg3hudDmhs6RFqwcVMo13AbVetV1U26cV8UVLkwnPvp5vUx7ly36zTQL9xnE1QnUAWW7pvHz2VVVdXNfELvU0Xsgb0Q97nRXRxWzujAxq2eZ3k094jXD6z30Bqgai5kJsU9S+qvRe1ollNYV8Gc0CwtVWf7c6hCaGbBmLx3HcvrF8foC0xez+dCaZ1fyoedoS0vcGkvL4Wu+eF9sdTeyS1beJaXqEv842gyG8ucRp9x6Umep3rzs0AjV5/z4cr+ogmh5pIaGkKbacyqke3LqbQO/PhR1G7fvnP841s5h9fPZ9W2+8gKTyKRSCQSiadH/uBJJBKJRCLx9PjcqUe1FC+vwSTKEtwd6RMl/YlS9uWjnGKJqzPynU5tzeXWOxH0ltxDhlUVKZEWUzbvZ7qTnxVUJZb1UH/cNEbkc6WxNDMcRzvsNU/7mt+h+jk21DYtFS+YAZpdpOnfMqtkwvRMVUhQ1NCFDyUwoYoZp/3O/r4rChTLo1UV88B6rs/uftVoZqvJapirZa6YyizzwCzLq0CpUMJMzO1qMNODEBRV8soaWEJ7SL2NKDhC/JtqDGllKA1N4W43jDZ54DuMxNrO8nvBeIuUVqBN5n06WLVIc1DV5TNVjls3oTuKy8asnxWulrUcxCx/wlTtr8CtSvO5j4n1yz1c6nKfvdlYmCfqANlIqy7SR9IM5E1Jh2kcKlXC9W9ZeO+nqe+sQ03zQnwaawaedQzqUM302HfYX0b3dTKtzPMa58c/m+czZngf5LkdaOc4lrk5omj+FoxPaS94xfg1BqPtXoMUaRDQMccnWxaCECuu8faOylQPTttKbC84Q1G5BqWJj+wXb+Rkvb2iwMJs8HA68vqZ88vxPWSFJ5FIJBKJxNMjf/AkEolEIpF4enyepWWsfLOvojFvabxDS8WS874J3xqynSit9l6iJkb7qibNmpaNGZZl94bSt53rKk+C4iXQIR5TNr1jmGXGlueMdOqPoTv/a1Ra5mc5Ni1jbIbQUu9TQKoragavISftbr4ZMHuqaT3fejgKgW3ZPISjWV/lM1gbE/NZR7kCH2emm58tLUd5XHrE99Gfbo3r8BFovd3gNrevlJsnTeKgjFzXvg/P+5GycTAdhZZapL9xBV2lZKLDZyWkqFVUzVDgfa8yS2Ua7+X9aPJ5h4nSeFCvTNdNyLxbHk+BVNWG7uM/LlCjExKsFvrN42aBKpSig5aSAvXYjEDz34JBnblljtEm5y5QfyoB7+YyVRwz/1BXHqv+W3jgV9at1E/ISHS5fEGWlhTwgTwo1Vi2V0ghNSpP2ZdVA4+2IDjMwbt2n0pW1RUVs2ZTbvYreWxpqTMqVtsf2PzMyQrLKGQkSrOV93wjJ+v7N5Rv7Ec9mVw9JrD3kBWeRCKRSCQST4/8wZNIJBKJROLp8TmlpfJFE7Y7Hd2W96+Uu6UPAgUSymhSWlIG+6VYKS0ptpkW/HlbmguqM8rDXSzH/vH3mupBxWnqtATFw/5n30bVCNBKXlqzr2x5JFSCqczy81qkXEHBY1kTUzHzbVRmqHZagllZOacOASzlfI0QJ5Uma/x9rimhXf83/R+Di91+NlbT+BhgVIhh2gwdFpQq3oMqQP4tsXzJdKrMKvdupljkagfOQd0GNdCYtcbr7cqzzBX0Det68X2kOvZNGtdqQ3Oa5aPxpGqkO/l5VaDDpJz21UFhynwfb457WFH4NP2v83r+CqQsVLNIP96gqOqQjYVabrrx+q/NL9dAde2bv0pvBSM5BrJpNhQlx3WgtMrr0+Q+um9CGOh99hSplVlKq7pHdbE3s399hejueERp9KYLH1lSKI1eUSOpfFT1+3HZb4uQGot7ERcUnrv9uZDe2gq/bE+I9Ob+3hfFnrbCLLuvqwA+HMoYvZ4dx0JpvfC643g6pvFgIpFIJBKJRP7gSSQSiUQi8fz4lNIKgg8r6NSspD1GSpRBmELJdaZd3rJW7Oq3JG5ped07JZRDVWKtGwqktjPeEnx7h2bT3NDb4TiUYs004pwhmBlqdLYfGtS0X/M79N49qGYJKgczxjh2zmW6giGW5mFB4aQ6Cton0CmWsTlnU35eKkvt5Tgo55iTIx39i5STIickHCGDhnU7ozoLJoeMqhTg1jDxEThTyr1HDdchHGs/z0gE6lE1jtcfaMH9HDFpBfN62kaaJF5DpD19zo+7fxPVjrwR6858ujrsC2Ez43P3s3561DJHyumPxETumfTeXLs4UaBOV05HLTftv4+qPtVYPmsyGc3oWECNuXOE97w/n2Ev4PWgiL2j0pKC0Tk17PN3jENVjdYYpK5BfbzfzvB38Ea+UwdFc0SlZTaUKmbzGP0+vaI+DnmPgcJ1XskTvHOPfs/cMxesqq3Z5P739J1lEeitaCirwav7Qjk+sre6d3fQyqq0mg0Vt4es8CQSiUQikXh65A+eRCKRSCQST4/6q7JhEolEIpFIJP63ICs8iUQikUgknh75gyeRSCQSicTTI3/wJBKJRCKReHrkD55EIpFIJBJPj/zBk0gkEolE4umRP3gSiUQikUg8Pf4bYc1suFwoLEMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
